import re
from random import randint, choice, shuffle
# 打开文件并读取内容
# 首先将所有的【】 换为 ()
# 要移除那个 "几年级下册"，在末尾追加 一个序号方便匹配。


def generate_poem_problems(grade, topic, difficulty):
    """
    根据年级选择不同的文件进行读取，然后调取函数poem_problems生成对应的问题
    :param grade:  实例 "一年级"
    :return:
    """
    file_name = './古诗文/' + grade + '古诗文.txt'
    with open(file_name, 'r', encoding='utf-8') as file:
        poems = file.read()
    # re.DOTALL .匹配所有字符包含换行符
    matches = re.findall(r'、(.*?)[0-9][0-9]', poems, re.DOTALL)
    # 输出匹配的内容
    total_len = len(matches)    # 诗歌的总个数
    # print(total_len)
    q_index = randint(0, total_len-1)
    match = matches[q_index]
    match = match.strip()
    poem = match.split('\n')
    title = poem[0]
    time = poem[1]
    content = poem[2:]
    question, answer = poem_problems(title, time, content)
    return question, answer

def poem_problems(title, time, content):
    """生成诗歌默写题目"""
    poem_len = len(content)
    # 被选的是哪一句
    chosen_index_1 = randint(0, poem_len-1)
    # 匹配半句
    matches = re.findall(r'[\u4e00-\u9fa5]+[，|？|。]', content[chosen_index_1], re.DOTALL)
    matches_len = len(matches)-1
    # 被选的是一句中的哪个半句
    chosen_index_2 = randint(0, matches_len)
    statement_len = len(matches[chosen_index_2])
    answer = matches[chosen_index_2][:-1]
    question = content[chosen_index_1].replace(matches[chosen_index_2], '_'*(statement_len-1)+matches[chosen_index_2][-1]) + f' 《{title}》' + f"{time}"
    # questions.append({'question_text': f"{problem}", 'answer': f"{answer}"})
    return question, answer


def generate_idom_question(grade, topic,difficulty):
    """根据年级和难度选择不同的文件，然后调取idiom_question生成词语问题并返回"""
    ops = ['近义词', '反义词']
    if topic == '混合':
        op = choice(ops)    # 随机选择题目是近义词还是反义词
    else:
        op = topic
    filename = './词汇/' + op + '/' + grade + '_' + difficulty + '_' + op + '.txt'    # 构建文件名字
    with open(filename, 'r', encoding='utf-8') as file:
        str_idioms = file.read()    # 读取文件
    idioms_list = str_idioms.split('\n\n')
    idioms = []
    for sys_words in idioms_list:
        two_pair_words = sys_words.split(' ')
        for pair_words in two_pair_words:
            words = pair_words.split('--')
            idioms.append(words)
    # print(grade, op, end='  ')
    # print('Grade:  ', grade, '   Difficulty: ', difficulty, 'topic: ', op,'  Number: ', len(idioms))  # todo 输出数量
    question, answer = idiom_question(idioms, op)
    return question, answer

def idiom_question(idioms, op):
    """根据词语列表 以及 op（选择的是近义词还是反义词）生成问题和答案
    """
    # print(idioms)
    question_idioms = [pair[0] for pair in idioms]
    answer_idioms = [pair[1] for pair in idioms]
    question_idiom = choice(question_idioms)
    question_index = question_idioms.index(question_idiom)  # 获取问题中的词语在列表的序号
    answer_idiom = answer_idioms[question_index]
    answer_idioms.pop(question_index)   # 从答案词语中先删除答案词语，然后从中随机获取三个词作为错误答案
    answers = []  # 应该防止出现重复的词语
    for i in range(3):
        new_idiom = choice(answer_idioms)
        answers.append(new_idiom)
        answer_idioms.remove(new_idiom)     # 从列表中删除该词语，从而防止重复选择
    answers.append(answer_idiom)    # 将正确答案加入到答案列表中
    options = ['A', 'B', 'C', 'D']
    shuffle(answers)     # 对答案列表随机排序
    answer = options[answers.index(answer_idiom)] + '. ' + answer_idiom  # 组成答案字符串
    question = "下列词语中是 {} 的{}的是____？\nA. {}\nB. {}\nC. {}\nD. {}".format(question_idiom, op, answers[0], answers[1], answers[2], answers[3]) # 组成问题字符串
    return question, answer



def get_request(grade, topic, number, difficulty):
    problems = []
    generates = [generate_idom_question, generate_poem_problems]
    if difficulty == 'hard':    # 根据不同难度选择不同的问题生成函数
        generate = generates[1]
    else:
        generate = generates[0]
    if topic == 0:
        type = '混合'
    elif topic == 1:
        type = '近义词'
    elif topic == 2:
        type = '反义词'
    else:
        questions = [{'question_text': "问题请求错误", 'answer': "暂无答案"}]
        return questions

    for i in range(number):
        question, answer = generate(grade, type, difficulty)
        if question == "问题请求错误" and answer == "暂无答案":
            problems.append((question, answer))
            break
        while (question, answer) in problems:
            # 防止出现重复的题目
            question, answer = generate(grade, type, difficulty)
        problems.append((question, answer))
    questions = []
    for i, (problem, answer) in enumerate(problems, 1):
        questions.append({'question_text': f"{problem}", 'answer': f"{answer}"})
    return questions

"""
数量要求:
 
easy 和 midum ： topic [混合， 近义词， 反义词]
hard topic[古诗文]
一年级easy  近义词题目 数量可达100  反义词题目 数量可达100
一年级 midum 近义词题目 数量可达100  反义词题目 数量可达100
一年级hard 数量可达40   共13首

二年级 easy 近义词题目 数量可达100  反义词题目 数量可达100
二年级 midum 近义词题目 数量可达100  反义词题目 数量可达100
二年级hard 数量可达50  共14首

三年级easy 近义词题目 数量可达100  反义词题目 数量可达100
三年级midum 近义词题目 数量可达100  反义词题目 数量可达100
三年级hard 数量可达70  共18首

四年级easy 近义词题目 数量可达100  反义词题目 数量可达100
四年级midum 近义词题目 数量可达100  反义词题目 数量可达100
四年级hard 数量可达70    共18首

五年级easy 近义词题目 数量可达100  反义词题目 数量可达100
五年级 midum 近义词题目 数量可达100  反义词题目 数量可达100
五年级hard 数量可达80   共21首

六年级easy 近义词题目 数量可达100  反义词题目 数量可达100
六年级 midum 近义词题目 数量可达100  反义词题目 数量可达100
六年级hard 古诗词默写数量可达100  共28首      
"""
if __name__ == '__main__':
    # questions = get_request('六年级', 3, 3, 'easy')
    # for q in questions:
    #     print(q)
    Grades = ['一年级', '二年级', '三年级', '四年级', '五年级', '六年级']
    for i in range(1):
        for grade in Grades:
            questions = get_request(grade, 3, 10, 'easy')
            for q in questions:
                print(q)

# question, answer = generate_poem_problems('一年级')
# print(question)
# print('*'*30)
# print(answer)
# title = '观书有感（其一）'
# time = '【宋】朱熹'
# content = ['半亩方塘一鉴开，天光云影共徘徊。', '问渠那得清如许？为有源头活水来。']
# for i in range(10):
#     print(randint(0, len(content)))
# # print(len(content))
# matches = re.findall(r'[\u4e00-\u9fa5]+[，|？|。]', content[0], re.DOTALL)
# for match in matches:
#     print(match)
#     print(len(match))
#     print('_'*(len(match)-1) + match[-1])